﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using NUnit.Framework;
using SistemaDeBastanteodePoderes.Persistencia;
using SistemaDeBastanteodePoderes.Dominio;

namespace SistemaDeBastanteodePoderes.Pruebas.DAO
{
    [TestFixture]
    public class Test_H4_1_TipoIntervencionDAO
    {
        ITipoIntervencionDAO tipoIntervencionDAO = null; // Utilizamos una referencia a la interfaz
        TipoIntervencion tipoCreado = null;

        [TestFixtureSetUp]
        public void InicializarPruebas()
        {
            tipoIntervencionDAO = new Persistencia.NH.TipoIntervencionDAO(); // Elegimos la implementación DAO a probar (ADO ó NHibernate)
            foreach (TipoIntervencion tipo in tipoIntervencionDAO.ListarTodos())
                tipoIntervencionDAO.Eliminar(tipo);
        }

        [Test]
        public void Test1_Crear()
        {
            TipoIntervencion tipoACrear = new TipoIntervencion();
            // 1. Validar que ocurra un error si no se ingresa el Servicio(nombre) del tipo de intervencion
            tipoACrear.Intervencion = null;
            Assert.Catch<Exception>(delegate
            {
                tipoCreado = tipoIntervencionDAO.Crear(tipoACrear);
            });

            // 2. Validar que se crea correctamente (sin error) el tipo de intervencion
            tipoACrear.Intervencion = "A SOLA FIRMA";
            Assert.DoesNotThrow(delegate
            {
                tipoCreado = tipoIntervencionDAO.Crear(tipoACrear);
            });

            // 3. Validar que se crea correctamente (sin error) un segundo tipo de intervencion
            tipoACrear.Intervencion = "EN CONJUNTO CON";
            Assert.DoesNotThrow(delegate
            {
                tipoCreado = tipoIntervencionDAO.Crear(tipoACrear);
            });

            // 4. Validar que el tipo creado no sea nulo, que tenga un código mayor que 0 y que la intervencion sea la ingresada
            Assert.IsNotNull(tipoCreado);
            Assert.Greater(tipoCreado.Codigo, 0);
            Assert.AreEqual(tipoCreado.Intervencion, tipoACrear.Intervencion);
        }
        [Test]
        public void Test2_Obtener()
        {
            TipoIntervencion obtenido = null;
            // 1. Validar que si se intenta obtener un tipo de intervencion inexistente se retorne null
            Assert.DoesNotThrow(delegate
            {
                obtenido = tipoIntervencionDAO.Obtener(1000);
            });
            Assert.IsNull(obtenido);
            // 2. Validar que se obtenga un tipo de intervencion correctamente (sin error)
            Assert.DoesNotThrow(delegate
            {
                obtenido = tipoIntervencionDAO.Obtener(tipoCreado.Codigo);
            });
            Assert.IsNotNull(obtenido);
        }
        [Test]
        public void Test3_Modificar()
        {
            TipoIntervencion tipoAModificar = tipoIntervencionDAO.Obtener(tipoCreado.Codigo);
            TipoIntervencion tipoModificado = null;

            // 1. Validar que ocurre un error si el intervencion ingresado es nulo
            tipoAModificar.Intervencion = null;
            Assert.Catch<Exception>(delegate
            {
                tipoModificado = tipoIntervencionDAO.Modificar(tipoAModificar);
            });

            // 2. Validar que se modifica correctamente (sin error) el tipo de intervencion
            tipoAModificar.Intervencion = "DE REGALO";
            Assert.DoesNotThrow(delegate
            {
                tipoModificado = tipoIntervencionDAO.Modificar(tipoAModificar);
            });

            // 3. Validar que el tipo de intervencion modificado no sea nulo y el intervencion sea el ingresado
            Assert.IsNotNull(tipoModificado);
            Assert.AreEqual(tipoAModificar.Intervencion, tipoModificado.Intervencion);
        }
        [Test]
        public void Test4_Eliminar()
        {
            TipoIntervencion tipoAEliminar = tipoIntervencionDAO.Obtener(tipoCreado.Codigo);

            // 1. Validar que ocurra un error si se intenta eliminar un tipo de intervencion inexistente
            Assert.Catch<Exception>(delegate
            {
                tipoIntervencionDAO.Eliminar(null);
            });

            // 2. Validar que se elimine un tipo de intervencion correctamente
            Assert.DoesNotThrow(delegate
            {
                tipoIntervencionDAO.Eliminar(tipoAEliminar);
            });

            // 3. Validar que el tipo de servicio eliminado ya no exista
            TipoIntervencion tipoEliminado = tipoIntervencionDAO.Obtener(tipoCreado.Codigo);
            Assert.IsNull(tipoEliminado);
        }
        [Test]
        public void Test5_Listar()
        {
            tipoIntervencionDAO.Crear(new TipoIntervencion() { Intervencion = "INTERVENCION1" });
            tipoIntervencionDAO.Crear(new TipoIntervencion() { Intervencion = "INTERVENCION2" });

            // 1. Validar que se listen sin errores los tipos de intervencion creados
            ICollection<TipoIntervencion> tiposExistentes = null;
            Assert.DoesNotThrow(delegate
            {
                tiposExistentes = tipoIntervencionDAO.ListarTodos();
            });

            // 2. Validar que retorne los 2 tipos de intervencion creados
            Assert.GreaterOrEqual(tiposExistentes.Count, 2);

            // 3. Validar que la Abreviacion de cada tipo de intervencion no sea nula
            foreach (TipoIntervencion tipo in tiposExistentes)
                Assert.IsNotNull(tipo.Intervencion);
        }

        [TestFixtureTearDown]
        public void FinalizarPruebas()
        {
            foreach (TipoIntervencion tipo in tipoIntervencionDAO.ListarTodos())
                tipoIntervencionDAO.Eliminar(tipo);
            Persistencia.NH.NHibernateHelper.CerrarFabrica();
        }
    }
}